home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource5 / 338_01 / bc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-02-25  |  16.1 KB  |  783 lines
  1. /* bc.c, code building function of as68 assembler
  2.  * 
  3.  *    (C) Copyright 1982 Steve Passe
  4.  *    All Rights Reserved
  5.  *
  6.  * version 1.00
  7.  * created 10/21/82
  8.  *
  9.  * version 1.01
  10.  *
  11.  *   8/30/83 ver. 1.01 modified for Aztec ver. 1.05g smp
  12.  *   10/12/87  split into root, pass1 and pass2 parts for overlay on pdp-11
  13.  */
  14.  
  15. /* begincode */
  16.  
  17. /* includes */
  18.  
  19. #include <stdio.h>
  20. #include "as68.h"
  21.  
  22. /* externals */
  23.  
  24. extern char pass;                /* present pass number, 1 or 2 */
  25. extern unsigned    line_count;            /* line number of source file */
  26. extern long loc_counter;            /* address to assemble obj code */
  27. extern int loc_plus;                /* increment to loc counter    */
  28. extern FLAG abs_long;                /* default to absolute long add.*/
  29. extern FLAG rorg;                /* in pc relative mode */
  30. extern char label[32];            /* buffer for label from preparse */
  31. extern char instr[33];            /* buffer for mnem, psdo or macro */
  32.  
  33. extern struct _mtable mtable[];            /* mnemonic    lookup table */
  34. extern struct _mvalue mvalue[];            /* mnemonic    code table */
  35. extern struct _oprnd op1, op2;          /* structs to hold operand val */
  36. extern char code[];                /* code array */
  37.  
  38. match(mt)
  39. register struct _mtable *mt;
  40. {
  41.     register int index;                    /* index to mvalue */
  42.     int type1 = _none, type2 = _none;            /* operand types */
  43.  
  44.     op_clear(&op1);
  45.     op_clear(&op2);
  46.     if (mt->_nops >= 1 && (type1 = op_eval(&op1)) < 0) { /* legal type found? */
  47.     err_out(BAD_OP1);        /* first op bad */
  48.     }
  49.     if (mt->_nops == 2 && (type2 = op_eval(&op2)) < 0) { /* second op? */
  50.     err_out(BAD_OP2);        /* no good */
  51.     }
  52.     if (type1 < 0 || type2 < 0) {
  53.     return ERROR;                /* use NULL opcode */
  54.     }
  55.     if ((index = type_search(mt, type1, type2))    <=0) {
  56.     switch (index) {
  57.     case ILGL_OP1:
  58.         err_out(ILGL_OP1);        /* no good */
  59.         return ERROR;
  60.     case ILGL_OP2:
  61.         err_out(ILGL_OP2);        /* no good */
  62.         return ERROR;
  63.     default:
  64.         return ERROR;
  65.     }
  66.     }
  67.     return index;
  68. }
  69.  
  70. type_search(mt,    type1, type2)
  71. struct _mtable *mt;
  72. int type1;
  73. int type2;
  74. {
  75.     register int x, y;                  /* count and index */
  76.     register int t1, t2;                /* temp for array value */
  77.  
  78.     for (x = mt->_mvc, y = mt->_mvi; x; --x, ++y) { /* search */
  79.                         /* find op1 match... */
  80.     if (((t1 = mvalue[y]._optyp1) == type1)     /* if exact match */
  81.     || ((!(t1 & ~0xf0)) && (t1 & type1))) { /* or classtyp and match */
  82.                         /* search for second match */
  83.         for ( ; (mvalue[y]._optyp1 == t1) && x; --x, ++y) {
  84.         if (((t2 = mvalue[y]._optyp2) == type2) /* 2nd matches */
  85.         || ((!(t2 & ~0xf0)) && (t2 & type2))) { /* or typ & match */
  86.             return y;               /* found a match */
  87.         }
  88.         }
  89.         return ILGL_OP2;
  90.     }
  91.     }
  92.     return ILGL_OP1;
  93. }
  94.  
  95. /* mask 3 bit immediate    data from op1 over bits 3-1 of code [0] */
  96.  
  97. bbb(op)
  98. register struct _oprnd *op;
  99. {
  100.     if (op->_data & ~7) return ERR_BBB;
  101.     code[0] |= (op->_data << 1);
  102.     return NULL;
  103. }
  104.  
  105. /* first ext word holds bit number (7/31) from first operand */
  106.  
  107. bbbx(size, op)
  108. int size;
  109. struct _oprnd *op;
  110. {
  111.     switch (size) {
  112.     case 3:
  113.     if (op->_data & ~7L) return ERR_BX3;            /* range? */
  114.     case 5:
  115.     if (op->_data & ~31L) return ERR_BX5;
  116.     code[3]    = op->_data;
  117.     return 1;                        /* 1 ext word */
  118.     default:
  119.     return ERR_BX;
  120.     }
  121. }
  122.  
  123. /** mask bits 3-1 of first byte with op1, 8 = 00 */
  124.  
  125. ccc(op)
  126. register struct _oprnd *op;
  127. {
  128.     if (op->_data < 1L || op->_data > 8L) return ERR_CCC;
  129.     code[0] |= (op->_data << 1) & 0x0f;
  130. /** if (op->_data != 8L) code[0] |= op->_data << 1; **/
  131.  
  132.     return NULL;                    /* no words added */
  133. }
  134.  
  135. /* mask bits 3-1 of first byte, or bits 2-0 of second, with op reg */
  136.  
  137. rsd(byt, op)
  138. int byt;
  139. register struct _oprnd *op;
  140. {
  141.     code[byt] |= (byt) ? op->_reg : op->_reg << 1;
  142.     return NULL;
  143. }
  144.  
  145. /* register mask list from op into ext */
  146.  
  147. mmkk(order, op)
  148. char order;
  149. register struct _oprnd *op;
  150. {
  151.     register int x;
  152.     unsigned u1 = 0;
  153.     unsigned m1 = 0x0001;
  154.     unsigned m2 = 0x8000;
  155.  
  156.     switch (order) {
  157.     case '>':
  158.     code[2]    = op->_reg_list    >> 8;               /* high byte */
  159.     code[3]    = op->_reg_list;                /* low byte */
  160.     return 1;
  161.     case '<':
  162.  
  163.     for (x = 15; x >= 0; --x) {
  164.         u1 |= (op->_reg_list & (m1 << x)) ? (m2 >> x) : 0;
  165.     }
  166.  
  167.     code[2]    = u1 >> 8;            /* high byte */
  168.     code[3]    = u1;               /* low byte */
  169.     return 1;
  170.     default:
  171.     return ERR_MK;
  172.     }
  173. }
  174.  
  175. /* combined e, f, g, h, and j routines,    12/4/82    */
  176.  
  177. efghj(arg, i, op)
  178. register char arg;
  179. register int i;
  180. register struct _oprnd *op;
  181. {
  182.     int len, displ;
  183.  
  184.     switch (op->_typ) {
  185.     case _ani:                  /* (an) */
  186.     if (arg == 'g') {
  187.         code[0] |= (op->_reg << 1);
  188.         code[1] |= 0x80;
  189.     }
  190.     else {
  191.         code[1] |= (0x10 | op->_reg);
  192.     }
  193.     return NULL;
  194.     case _pd_ani:                /* -(an) */
  195.     switch (arg) {
  196.     case 'g':
  197.         code[0] |= (0x01 | op->_reg    << 1);
  198.         return NULL;
  199.     case 'j': return ERR_J;
  200.     case 'h': return ERR_H;
  201.     default:
  202.         code[1] |= (0x20 | op->_reg);
  203.         return NULL;
  204.     }
  205.  
  206.     case _ani_pi:                /* (an)+ */
  207.     switch (arg) {
  208.     case 'g':
  209.         code[0] |= (op->_reg << 1);
  210.         code[1] |= 0xc0;
  211.         return NULL;
  212.     case 'j': return ERR_J;
  213.     case 'h': return ERR_H;
  214.     default:
  215.         code[1] |= (0x18 | op->_reg);
  216.         return NULL;
  217.     }
  218.  
  219.     case _d16_ani:                /* d16(an) */
  220.     switch (arg) {
  221.     case 'e':
  222.     case 'j':
  223.         if (/**rorg**/ op->_rel_lbl) {
  224.         op->_ireg = op->_reg;            /* reg is an index */
  225.         op->_iregtyp = op->_regtyp;        /* move type */
  226.         op->_displ -= (loc_counter + 2);    /* make pc relative    */
  227.         code[1]    |= 0x3b;
  228.         return _d8_i(i,    op);            /* indexed label */
  229.         }
  230.         break;
  231.     case 'g':
  232.         code[0] |= (0x01 | op->_reg    << 1);
  233.         code[1] |= 0x40;
  234.         return _d16(i, op);
  235.     }
  236.     code[1]    |= (0x28 | op->_reg);
  237.     return _d16(i, op);
  238.  
  239.     case _d8_anx:                /* d8(an,i) */
  240.     if (arg == 'g') {
  241.         code[0] |= (0x01 | op->_reg    << 1);
  242.         code[1] |= 0x80;
  243.     }
  244.     else {
  245.         code[1] |= (0x30 | op->_reg);
  246.     }
  247.     return _d8_i(i,    op);
  248.  
  249.     case _address:    /* abs. add., short or long, or label if _rel_lbl */
  250.     switch (arg) {
  251.     case 'e':
  252.     case 'j':
  253.         if (/**rorg**/ op->_rel_lbl) {
  254.         code[1]    |= 0x3a;
  255.         op->_displ = op->_addr - (loc_counter + 2); /* rel. to pc */
  256.         return _d16(i, op);            /* finish as 'label' */
  257.         }
  258.         break;
  259.     case 'g':
  260.         code[1] |= 0xc0;
  261.         if (op->_long_val) {
  262.         code[0]    |= 0x03;
  263.         code[i++] = op->_addr >> 24;
  264.         code[i++] = op->_addr >> 16;
  265.         len = 2;
  266.         }
  267.         else {
  268.         code[0]    |= (0x01);
  269.         len = 1;
  270.         }
  271.         code[i++] = op->_addr >> 8;
  272.         code[i] = op->_addr;
  273.         return len;
  274.     }
  275.     if (op->_long_val) {
  276.         code[1] |= (0x39);
  277.         code[i++] = op->_addr >> 24;
  278.         code[i++] = op->_addr >> 16;
  279.         len = 2;
  280.     }
  281.     else {
  282.         code[1] |= (0x38);
  283.         len = 1;
  284.     }
  285.     code[i++] = op->_addr >> 8;
  286.     code[i]    = op->_addr;
  287.     return len;
  288.  
  289.     case _label:                /* relative label */
  290.     switch (arg) {
  291.     case 'g': return ERR_G;
  292.     case 'f': return ERR_F;
  293.     case 'h': return ERR_H;
  294.     default:
  295.         code[1] |= 0x3a;
  296.         op->_displ -= (loc_counter + 2);    /* rel. to pc */
  297.         return _d16(i, op);
  298.     }
  299.  
  300.     case _labeli:                /* label(i) */
  301.     switch (arg) {
  302.     case 'g': return ERR_G;
  303.     case 'f': return ERR_F;
  304.     case 'h': return ERR_H;
  305.     default:
  306.         code[1] |= 0x3b;
  307.         op->_displ -= (loc_counter + 2);    /* rel. to pc */
  308.         return _d8_i(i, op);
  309.     }
  310.  
  311.     default:
  312.     return ERR_EFGHJ;
  313.     }
  314. }
  315.  
  316. _d16(i,    op)
  317. register int i;
  318. register struct _oprnd *op;
  319. {
  320.     if ((op->_displ > 32767) || (op->_displ < -32768)) return ERR_D16;
  321.     code[i] = op->_displ >> 8;              /* displacement... */
  322.     code[i+1] = op->_displ;                /* ...into ext */
  323.     return 1;                       /* 1 ext word returned */
  324. }
  325.  
  326. _d8_i(i, op)
  327. register int i;
  328. register struct _oprnd *op;
  329. {
  330.     if ((op->_displ > 127) || (op->_displ < -128)) return ERR_D8I;
  331.     if (op->_iregtyp == 'a') code[i] |= 0x80;        /* index is addr reg */
  332.     code[i] |= (op->_ireg << 4);            /* add index reg # */
  333.     if (op->_inxl) code[i] |= 0x08;            /* mark long index size */
  334.     code[i+1] = op->_displ;                /* 8 bit displacement */
  335.     return 1;
  336. }
  337.  
  338. /* 8/16 bit address displacement */
  339.  
  340. xxxx(size, op)
  341. register int size;
  342. register struct _oprnd *op;
  343. {
  344.     register int displ;
  345.  
  346.     switch (op->_typ) {
  347.     case _address:                    /* absolute    address    */
  348.     displ = op->_addr - (loc_counter + 2);      /* make relative to pc */
  349.     break;
  350.     case _label:                    /* relative    address    */
  351.     displ = op->_displ;
  352.     break;
  353.     default:                        /* somethings wrong... */
  354.     return ERR_XXX;
  355.     }
  356.     switch (size) {
  357.     case 8:
  358.         if (displ > 127 || displ < -128) return ERR_XX; /* check range */
  359.         code[1] |= displ;                /* put into array */
  360.         return NULL;                /* no ext word */
  361.     case 16:
  362.         if (displ > 32766 || displ < -32768) return ERR_XXXX; /* range */
  363.         code[2] = displ >> 8;
  364.         code[3] = displ;
  365.         return 1;                   /* 1 ext word returned */
  366.     default:
  367.         return ERR_XXX;
  368.     }
  369. }
  370.  
  371. /** */
  372.  
  373. yy(op)
  374. register struct _oprnd *op;
  375. {
  376.     if (op->_data > 255L || op->_data < -128L) return ERR_Y;
  377.     code[1] = op->_data;
  378.     return NULL;                /* no ext word */
  379. }
  380.  
  381. oyz(size, op)
  382. int size;
  383. register struct _oprnd *op;
  384. {
  385.     switch (size) {
  386.     case 8:
  387.     if (op->_data > 255L || op->_data < -128L) return ERR_OY;
  388.     code[3]    = op->_data;
  389.     return 1;                /* one ext word added */
  390.     case 16:
  391.     if (op->_data > 65535L || op->_data < -32768L) return ERR_YY;
  392.     code[2]    = op->_data >> 8;
  393.     code[3]    = op->_data;
  394.     return 1;                /* one ext word added */
  395.     case 32:
  396.     code[2]    = op->_data >> 24;
  397.     code[3]    = op->_data >> 16;
  398.     code[4]    = op->_data >> 8;
  399.     code[5]    = op->_data;
  400.     return 2;
  401.     default:
  402.     return ERR_OYZ;
  403.     }
  404. }
  405.  
  406. /*
  407. byte 1  byte 2  byte 3  byte 4  byte 5  byte 6  byte 7  byte 8  byte 9  byte 10
  408. */
  409.  
  410. /* none none    */
  411.  
  412. nn()
  413. {
  414.     return NULL;                /* no action required */
  415. }
  416.  
  417. /*  none    none    zero    yy  */
  418.  
  419. nnoy()
  420. {
  421.     return oyz(8, &op1);            /* 8 bits imd data */
  422. }
  423.  
  424. /*  none    none    yyyy    */
  425.  
  426. nnyy()
  427. {
  428.     return oyz(16, &op1);            /* 16 bits imd data */
  429. }
  430.  
  431. /*  none    xx  */
  432.  
  433. nx()
  434. {
  435.     return xxxx(8, &op1);            /* 16 bit displ from op1 */
  436. }
  437.  
  438. /*  none    none    xxxx    */
  439.  
  440. nnxx()
  441. {
  442.     return xxxx(16, &op1);            /* 16 bit displ from op1 */
  443. }
  444.  
  445. /*  none    ddd */
  446.  
  447. nd()
  448. {
  449.     return rsd(1, &op1);            /* dest reg from op1 into byte 1 */
  450. }
  451.  
  452. nd2()
  453. {
  454.     return rsd(1, &op2);            /* dest reg from op2 into byte 1 */
  455. }
  456.  
  457. /*  none    ddd     zero    bbbbb   */
  458.  
  459. ndob()
  460. {
  461.     rsd(1, &op2);                /* dest reg from op2 into byte 1 */
  462.     return bbbx(5, &op1);            /* bit field spec into first ext */
  463. }
  464.  
  465. /*  none    ddd     kkkk    */
  466.  
  467. ndkk()
  468. {
  469.     rsd(1, &op2);                /* dest reg from op2 into byte 1 */
  470.     return mmkk('<', &op1);            /* reglist from op1 into ext */
  471. }
  472.  
  473. /*  none    ddd     zero    yy  */
  474.  
  475. ndoy()
  476. {
  477.     rsd(1, &op2);                /* dest reg from op2 into byte 1 */
  478.     return oyz(8, &op1);            /* 8 bits imd data */
  479. }
  480.  
  481. /*  none    ddd     yyyy    */
  482.  
  483. ndyy()
  484. {
  485.     rsd(1, &op2);                /* dest reg from op2 into byte 1 */
  486.     return oyz(16, &op1);            /* 16 bits of immediate data */
  487. }
  488.  
  489. /*  none    ddd     yyyy        zzzz    */
  490.  
  491. ndyz()
  492. {
  493.     rsd(1, &op2);                /* dest reg from op2 into byte 1 */
  494.     return oyz(32, &op1);            /* 32 bits of immediate data */
  495. }
  496.  
  497. /*  none    eeeeee    [ext]        [ext]    */
  498.  
  499. ne()
  500. {
  501.     return efghj('e', 2, &op1);
  502. }
  503.  
  504. /*  none    ffffff    [ext]        [ext]    */
  505.  
  506. nf()
  507. {
  508.     return efghj('f', 2, &op1);
  509. }
  510.  
  511. nf2()
  512. {
  513.     return efghj('f', 2, &op2);
  514. }
  515.  
  516. /*  none    ffffff  zero    bbb     [ext]        [ext]    */
  517.  
  518. nfob()
  519. {
  520.     bbbx(3, &op1);
  521.     return (efghj('f', 4, &op2) + 1);
  522. }
  523.  
  524. /*  none    ffffff  zero    yy      [ext]        [ext]    */
  525.  
  526. nfoy()
  527. {
  528.     oyz(8, &op1);                /* 8 bits imd data */
  529.     return (efghj('f', 4, &op2) + 1);           /* op2 destination address */
  530. }
  531.  
  532. /*  none    ffffff    yyyy        [ext]        [ext]    */
  533.  
  534. nfyy()
  535. {
  536.     oyz(16, &op1);                /* 16 bits imd data */
  537.     return (efghj('f', 4, &op2) + 1);           /* op2 destination address */
  538. }
  539.  
  540. /*  none    ffffff    yyyy        zzzz        [ext]        [ext] */
  541.  
  542. nfyz()
  543. {
  544.     oyz(32, &op1);                /* 32 bits imd data */
  545.     return (efghj('f', 6, &op2) + 2);           /* op2 destination address */
  546. }
  547.  
  548. /*  none    hhhhhh    mmmm        [ext]        [ext]    */
  549.  
  550. nhmm()
  551. {
  552.     mmkk('>', &op1);                /* reglist from op1 into ext */
  553.     return (efghj('h', 4, &op2) + 1);           /* op2 destination address */
  554. }
  555.  
  556. /*  none    jjjjjj    [ext]        [ext]    */
  557.  
  558. nj()
  559. {
  560.     return efghj('j', 2, &op1);
  561. }
  562.  
  563. /*  none    jjjjjj    mmmm        [ext]        [ext]    */
  564.  
  565. njmm()
  566. {
  567.     mmkk('>', &op2);            /* reglist from op2 into ext */
  568.     return (efghj('j', 4, &op1) + 1);
  569. }
  570.  
  571. /*  none    rrr */
  572.  
  573. nr()
  574. {
  575.     return rsd(1, &op1);        /* source reg from op1 into byte 1 */
  576. }
  577.  
  578. nr2()
  579. {
  580.     return rsd(1, &op2);        /* source reg from op2 into byte 1 */
  581. }
  582.  
  583. /*  none    rrr     xxxx    */
  584.  
  585. nrxx()
  586. {
  587.     rsd(1, &op1);            /* source reg from op1 into byte 1 */
  588.     return xxxx(16, &op2);        /* 16 bit displ from op1 */
  589. }
  590.  
  591. /*  none    rrr        yyyy    */
  592.  
  593. nryy()        /* special for LINK.W (aka LINK) instr */
  594. {
  595.     rsd(1, &op1);            /* address reg from op1 to byte1 */
  596.     return oyz(16, &op2);        /* 16bit displ to op2 */
  597. }
  598.  
  599. /*  none    sss [same as 'none rrr':nr()] */
  600.  
  601. /*  none    sss     mmmm    */
  602.  
  603. nsmm()
  604. {
  605.     rsd(1, &op1);            /* source reg from op1 into byte 1 */
  606.     return mmkk('>', &op2);        /* reglist from op1 into ext */
  607. }
  608.  
  609. /*  none    vvvv    */
  610.  
  611. nv()
  612. {
  613.     if (op1._data & ~15l) return ERR_V;
  614.     code[1] |= op1._data;
  615.     return NULL;
  616. }
  617.  
  618. /*  bbb     ddd */
  619.     /* same as ccc  ddd (sort of) */
  620.  
  621. /*  bbb     ffffff    [ext]        [ext]    */
  622.     /* bbb is a misnomer for these two... */
  623.  
  624. cf()
  625. {
  626.     ccc(&op1);
  627.     return efghj('f', 2, &op2);
  628. }
  629.  
  630. /*  ccc     ddd */
  631.  
  632. cd()
  633. {
  634.     ccc(&op1);
  635.     return rsd(1, &op2);
  636. }
  637. /*  ddd     none    zero    yy  */
  638.  
  639. dnoy()
  640. {
  641.     rsd(0, &op2);
  642.     return oyz(8, &op1);            /* 8 bits of immediate data */
  643. }
  644.  
  645. /*  ddd     none    yyyy    */
  646.  
  647. dnyy()
  648. {
  649.     rsd(0, &op2);
  650.     return oyz(16, &op1);            /* 16 bits of immediate data */
  651. }
  652.  
  653. /*  ddd     none    yyyy        zzzz    */
  654.  
  655. dnyz()
  656. {
  657.     rsd(0, &op2);
  658.     return oyz(32, &op1);            /* 32 bits of immediate data */
  659. }
  660.  
  661. /*  ddd     eeeeee    [ext]        [ext]    */
  662.  
  663. de()
  664. {
  665.     rsd(0, &op2);                /* dest reg from op2 into byte 1 */
  666.     return efghj('e', 2, &op1);
  667. }
  668.  
  669. /*  ddd     jjjjjj    [ext]        [ext]    */
  670.  
  671. dj()
  672. {
  673.     rsd(0, &op2);
  674.     return efghj('j', 2, &op1);
  675. }
  676.  
  677. /*  ddd     rrr */
  678.  
  679. dr()
  680. {
  681.     rsd(0, &op2);
  682.     return rsd(1, &op1);        /* source reg from op1 into byte 1 */
  683. }
  684.  
  685. /*  ddd     sss [same as 'ddd rrr': dr()] */
  686.  
  687. /*  ddd     sss     xxxx    */
  688.  
  689. dsxx()
  690. {
  691.     rsd(0, &op2);
  692.     rsd(1, &op1);            /* source reg from op1 into byte 1 */
  693.     return xxxx(16, &op1);        /* 16 bit displ from op1 */
  694. }
  695.  
  696. /*  ddd     yy  */
  697.  
  698. dy()
  699. {
  700.     rsd(0, &op2);
  701.     return yy(&op1);
  702. }
  703.  
  704. /*  gggggg  none    zero    yy      [ext]        [ext]    */
  705.  
  706. gnoy()
  707. {
  708.     oyz(8, &op1);            /* 8 bits of immediate data */
  709.     return (efghj('g', 4, &op2) + 1);
  710. }
  711.  
  712. /*  gggggg  none    yyyy        [ext]        [ext]    */
  713.  
  714. gnyy()
  715. {
  716.     oyz(16, &op1);            /* 16 bits of immediate data */
  717.     return (efghj('g', 4, &op2) + 1);
  718. }
  719.  
  720. /*  gggggg  none    yyyy        zzzz        [ext]        [ext]   */
  721.  
  722. gnyz()
  723. {
  724.     oyz(32, &op1);            /* 32 bits of immediate data */
  725.     return (efghj('g', 6, &op2) + 2);
  726. }
  727.  
  728. /*  gggggg  eeeeee    [exts]        [exts]        [extd]        [extd]  */
  729.  
  730. ge()
  731. {
  732.     int temp;
  733.     temp = efghj('e', 2, &op1);
  734.     return (efghj('g', 2 + (temp * 2), &op2) + temp);
  735. }
  736.  
  737. /*  gggggg  sss     [ext]        [ext]    */
  738.  
  739. gs()
  740. {
  741.     rsd(1, &op1);
  742.     return efghj('g', 2, &op2);
  743. }
  744.  
  745. /*  rrr     ddd */
  746.  
  747. rd()
  748. {
  749.     rsd(0, &op1);
  750.     return rsd(1, &op2);
  751. }
  752.  
  753. /*  rrr     ffffff    [ext]        [ext]    */
  754.  
  755. rf()
  756. {
  757.     rsd(0, &op1);
  758.     return efghj('f', 2, &op2);
  759. }
  760.  
  761. /*  sss     ddd [same as 'rrr ddd': rd()] */
  762.  
  763. /*  sss     ddd     xxxx    */
  764.  
  765. sdxx()
  766. {
  767.     rsd(0, &op1);            /* source reg from op1 into byte 1 */
  768.     rsd(1, &op2);
  769.     return xxxx(16, &op2);        /* 16 bit displ from op2 */
  770. }
  771.  
  772. /*  sss     ffffff    [ext]        [ext] */
  773.  
  774. sf()
  775. {
  776.     rsd(0, &op1);            /* source reg from op1 into byte 0 */
  777.     return efghj('f', 2, &op2);
  778. }
  779.  
  780. /* endcode */
  781.  
  782.  
  783.